﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Kendo.Mvc.Extensions;
using Kendo.Mvc.UI;
using rosata.Areas.Admin.Filters;
using rosata.Providers.PromozioniProvider;

namespace rosata.Areas.Admin.Controllers
{
    public class PromozioniAdminController : Controller
    {
        private readonly IPromozioniProvider _promozioniProvider;

        public PromozioniAdminController(IPromozioniProvider promozioniProvider)
        {
            _promozioniProvider = promozioniProvider;
        }

        //
        // GET: /Admin/Promozioni/
        [CheckAdminFilter]
        public PartialViewResult Index()
        {
            return PartialView();
        }

        [CheckAdminFilter]
        public ActionResult GetPromozioni([DataSourceRequest] DataSourceRequest request)
        {
            List<PromozioneDto> listaPromozioni = new List<PromozioneDto>();
            try
            {
                listaPromozioni = _promozioniProvider.ListaPromozioni();
            }
            catch (Exception exception)
            {
                ModelState.AddModelError("ERRORE", "PROBLEMA in fase di lettura degli ordini utente, ERRORE: " + exception.StackTrace);
                //CommonUtilities.WriteLog("errore", "PROBLEMA in fase di lettura degli ordini utente, ERRORE: " + exception.StackTrace, "problema in fase di lettura degli ordini", "", "", exception);
            }
            return Json(listaPromozioni.ToDataSourceResult(request, ModelState));
        }

        [CheckAdminFilter]
        public PartialViewResult FormAddPromozioni()
        {
            return PartialView();
        }

        [HttpPost]
        [CheckAdminFilter]
        public ViewResult AddPromozione(PromozioneDto prodottoVm)
        {
            CaricamentoPromozione caricamentoPromozione = new CaricamentoPromozione();
            try
            {
                _promozioniProvider.AddPromozione(prodottoVm);
                
                caricamentoPromozione.CaricamentoOk = true;
                caricamentoPromozione.Messaggio = "promozione caricata correttamente";
            }
            catch (Exception exception)
            {
                caricamentoPromozione.CaricamentoOk = false;
                caricamentoPromozione.Messaggio = "errore in fase di caricamento della promozione, ERRORE: " + exception.Message;
            }

            return View("MessaggioCaricamentoPromozione", caricamentoPromozione);
        }

        [CheckAdminFilter]
        public ActionResult Edit([DataSourceRequest] DataSourceRequest request, PromozioneDto promozioneDto)
        {
            string errore = ControllaErroriModelState(ModelState, promozioneDto);
            List<PromozioneDto> listaPromozioni = new List<PromozioneDto>();
            if (errore.Length != 0)
            {
                ModelState.AddModelError("ERRORE", errore);
                return Json(ModelState.ToDataSourceResult());
            }
            try
            {
                _promozioniProvider.UpdatePromozione(promozioneDto);
                listaPromozioni = _promozioniProvider.ListaPromozioni();
            }
            catch (Exception exception)
            {
                ModelState.AddModelError("ERRORE", "PromozioniController->Edit: Modelstate non è valido, ERRORE:" + exception.Message);
            }

            return Json(listaPromozioni.ToDataSourceResult(request, ModelState));
        }

        [HttpPost]
        public ActionResult SalvaImmaginePiccola(HttpPostedFileBase immaginePiccola, int idPromo)
        {
            try
            {
                _promozioniProvider.UpdateImmaginePiccolaPromozione(idPromo, immaginePiccola);
            }
            catch (Exception exception)
            {
                return Content(exception.Message);
            }

            // Return an empty string to signify success
            return Content("");
        }

        [HttpPost]
        public ActionResult SalvaImmagineHeader(HttpPostedFileBase immagineHeaderSito, int idPromo)
        {
            try
            {
                _promozioniProvider.UpdateImmagineHeaderPromozione(idPromo, immagineHeaderSito);
            }
            catch (Exception exception)
            {
                return Content(exception.Message);
            }

            // Return an empty string to signify success
            return Content("");
        }

        [HttpPost]
        public ActionResult SalvaDocumento(HttpPostedFileBase documento, int idPromo)
        {
            try
            {
                _promozioniProvider.UpdateDocumentoPromozione(idPromo, documento);
            }
            catch (Exception exception)
            {
                return Content(exception.Message);
            }

            // Return an empty string to signify success
            return Content("");
        }

        private string ControllaErroriModelState(ModelStateDictionary modelState, PromozioneDto promozioneDto)
        {
            if (promozioneDto == null)
            {
                ModelState.AddModelError("ERRORE", "PromozioniController->Edit: promozioneDto è nullo");
                return "PromozioniController->Edit: promozioneDto è nullo";
            }
            else if (!ModelState.IsValid)
            {
                List<ModelError> listaModelErrors = CommonUtilities.GetModelErrorsFromModelStateDictionary(modelState);

                //se l'errore è solo quello della mancanza di caricamento della immagine piccola, ma che non è obbligatoria
                if (listaModelErrors.Count == 1 &&
                    listaModelErrors.Count(l => l.ErrorMessage.Contains("ImmaginePiccola")) == 1)
                {
                    //se l'errore è solo quello della mancanza di ImmaginePiccola
                    //lo elimino dal modelstate perchè non si tratta di un 
                    //errore in quanto l'immagine piccola non è obbligatoria 
                    modelState.Remove("ImmaginePiccola");
                }
                else
                {
                    //se invece ho un errore, prendo su il messaggio e lo ritorno al controller
                    string messaggio = CommonUtilities.GetModelErrorStringFromModelState(modelState);
                    return messaggio;
                }
              
            }
            return "";
        }

        public ActionResult Delete([DataSourceRequest] DataSourceRequest request, PromozioneDto promozioneDto)
        {
            try
            {
                string errore = ControllaErroriModelState(ModelState, promozioneDto);
                if (errore.Length != 0)
                {
                    ModelState.AddModelError("ERRORE", errore);
                }

                _promozioniProvider.DeletePromozione(promozioneDto.Id);
            }
            catch(Exception exception)
            {
                ModelState.AddModelError("ERRORE", exception.Message);   
            }
            return Json(ModelState.ToDataSourceResult());
        }

        public class CaricamentoPromozione
        {
            public bool CaricamentoOk { get; set; }  
            public string Messaggio { get; set; }
        }
    }
}